define('ace/ext/menu_tools/overlay_page', ['require', 'exports', 'module', 'ace/lib/dom'], function(require, exports, module) {
  'use strict'
  var dom = require('../../lib/dom')
  var cssText = '#ace_settingsmenu, #kbshortcutmenu {\
background-color: #F7F7F7;\
color: black;\
box-shadow: -5px 4px 5px rgba(126, 126, 126, 0.55);\
padding: 1em 0.5em 2em 1em;\
overflow: auto;\
position: absolute;\
margin: 0;\
bottom: 0;\
right: 0;\
top: 0;\
z-index: 9991;\
cursor: default;\
}\
.ace_dark #ace_settingsmenu, .ace_dark #kbshortcutmenu {\
box-shadow: -20px 10px 25px rgba(126, 126, 126, 0.25);\
background-color: rgba(255, 255, 255, 0.6);\
color: black;\
}\
.ace_optionsMenuEntry:hover {\
background-color: rgba(100, 100, 100, 0.1);\
transition: all 0.3s\
}\
.ace_closeButton {\
background: rgba(245, 146, 146, 0.5);\
border: 1px solid #F48A8A;\
border-radius: 50%;\
padding: 7px;\
position: absolute;\
right: -8px;\
top: -8px;\
z-index: 100000;\
}\
.ace_closeButton{\
background: rgba(245, 146, 146, 0.9);\
}\
.ace_optionsMenuKey {\
color: darkslateblue;\
font-weight: bold;\
}\
.ace_optionsMenuCommand {\
color: darkcyan;\
font-weight: normal;\
}\
.ace_optionsMenuEntry input, .ace_optionsMenuEntry button {\
vertical-align: middle;\
}\
.ace_optionsMenuEntry button[ace_selected_button=true] {\
background: #e7e7e7;\
box-shadow: 1px 0px 2px 0px #adadad inset;\
border-color: #adadad;\
}\
.ace_optionsMenuEntry button {\
background: white;\
border: 1px solid lightgray;\
margin: 0px;\
}\
.ace_optionsMenuEntry button:hover{\
background: #f0f0f0;\
}'
  dom.importCssString(cssText)
  module.exports.overlayPage = function overlayPage(editor, contentElement, top, right, bottom, left) {
    top = top ? 'top: ' + top + ';' : ''
    bottom = bottom ? 'bottom: ' + bottom + ';' : ''
    right = right ? 'right: ' + right + ';' : ''
    left = left ? 'left: ' + left + ';' : ''

    var closer = document.createElement('div')
    var contentContainer = document.createElement('div')

    function documentEscListener(e) {
      if (e.keyCode === 27) {
        closer.click()
      }
    }

    closer.style.cssText = 'margin: 0; padding: 0; ' +
        'position: fixed; top:0; bottom:0; left:0; right:0;' +
        'z-index: 9990; ' +
        'background-color: rgba(0, 0, 0, 0.3);'
    closer.addEventListener('click', function() {
      document.removeEventListener('keydown', documentEscListener)
      closer.parentNode.removeChild(closer)
      editor.focus()
      closer = null
    })
    document.addEventListener('keydown', documentEscListener)

    contentContainer.style.cssText = top + right + bottom + left
    contentContainer.addEventListener('click', function(e) {
      e.stopPropagation()
    })

    var wrapper = dom.createElement('div')
    wrapper.style.position = 'relative'

    var closeButton = dom.createElement('div')
    closeButton.className = 'ace_closeButton'
    closeButton.addEventListener('click', function() {
      closer.click()
    })

    wrapper.appendChild(closeButton)
    contentContainer.appendChild(wrapper)

    contentContainer.appendChild(contentElement)
    closer.appendChild(contentContainer)
    document.body.appendChild(closer)
    editor.blur()
  }
})

define('ace/ext/modelist', ['require', 'exports', 'module'], function(require, exports, module) {
  'use strict'

  var modes = []
  function getModeForPath(path) {
    var mode = modesByName.text
    var fileName = path.split(/[\/\\]/).pop()
    for (var i = 0; i < modes.length; i++) {
      if (modes[i].supportsFile(fileName)) {
        mode = modes[i]
        break
      }
    }
    return mode
  }

  var Mode = function(name, caption, extensions) {
    this.name = name
    this.caption = caption
    this.mode = 'ace/mode/' + name
    this.extensions = extensions
    var re
    if (/\^/.test(extensions)) {
      re = extensions.replace(/\|(\^)?/g, function(a, b) {
        return '$|' + (b ? '^' : '^.*\\.')
      }) + '$'
    } else {
      re = '^.*\\.(' + extensions + ')$'
    }

    this.extRe = new RegExp(re, 'gi')
  }

  Mode.prototype.supportsFile = function(filename) {
    return filename.match(this.extRe)
  }
  var supportedModes = {
    ABAP: ['abap'],
    ABC: ['abc'],
    ActionScript: ['as'],
    ADA: ['ada|adb'],
    Apache_Conf: ['^htaccess|^htgroups|^htpasswd|^conf|htaccess|htgroups|htpasswd'],
    AsciiDoc: ['asciidoc|adoc'],
    ASL: ['dsl|asl'],
    Assembly_x86: ['asm|a'],
    AutoHotKey: ['ahk'],
    BatchFile: ['bat|cmd'],
    Bro: ['bro'],
    C_Cpp: ['cpp|c|cc|cxx|h|hh|hpp|ino'],
    C9Search: ['c9search_results'],
    Cirru: ['cirru|cr'],
    Clojure: ['clj|cljs'],
    Cobol: ['CBL|COB'],
    coffee: ['coffee|cf|cson|^Cakefile'],
    ColdFusion: ['cfm'],
    CSharp: ['cs'],
    Csound_Document: ['csd'],
    Csound_Orchestra: ['orc'],
    Csound_Score: ['sco'],
    CSS: ['css'],
    Curly: ['curly'],
    D: ['d|di'],
    Dart: ['dart'],
    Diff: ['diff|patch'],
    Dockerfile: ['^Dockerfile'],
    Dot: ['dot'],
    Drools: ['drl'],
    Edifact: ['edi'],
    Eiffel: ['e|ge'],
    EJS: ['ejs'],
    Elixir: ['ex|exs'],
    Elm: ['elm'],
    Erlang: ['erl|hrl'],
    Forth: ['frt|fs|ldr|fth|4th'],
    Fortran: ['f|f90'],
    FSharp: ['fsi|fs|ml|mli|fsx|fsscript'],
    FTL: ['ftl'],
    Gcode: ['gcode'],
    Gherkin: ['feature'],
    Gitignore: ['^.gitignore'],
    Glsl: ['glsl|frag|vert'],
    Gobstones: ['gbs'],
    golang: ['go'],
    GraphQLSchema: ['gql'],
    Groovy: ['groovy'],
    HAML: ['haml'],
    Handlebars: ['hbs|handlebars|tpl|mustache'],
    Haskell: ['hs'],
    Haskell_Cabal: ['cabal'],
    haXe: ['hx'],
    Hjson: ['hjson'],
    HTML: ['html|htm|xhtml|vue|we|wpy'],
    HTML_Elixir: ['eex|html.eex'],
    HTML_Ruby: ['erb|rhtml|html.erb'],
    INI: ['ini|conf|cfg|prefs'],
    Io: ['io'],
    Jack: ['jack'],
    Jade: ['jade|pug'],
    Java: ['java'],
    JavaScript: ['js|jsm|jsx'],
    JSON: ['json'],
    JSONiq: ['jq'],
    JSP: ['jsp'],
    JSSM: ['jssm|jssm_state'],
    JSX: ['jsx'],
    Julia: ['jl'],
    Kotlin: ['kt|kts'],
    LaTeX: ['tex|latex|ltx|bib'],
    LESS: ['less'],
    Liquid: ['liquid'],
    Lisp: ['lisp'],
    LiveScript: ['ls'],
    LogiQL: ['logic|lql'],
    LSL: ['lsl'],
    Lua: ['lua'],
    LuaPage: ['lp'],
    Lucene: ['lucene'],
    Makefile: ['^Makefile|^GNUmakefile|^makefile|^OCamlMakefile|make'],
    Markdown: ['md|markdown'],
    Mask: ['mask'],
    MATLAB: ['matlab'],
    Maze: ['mz'],
    MEL: ['mel'],
    MIXAL: ['mixal'],
    MUSHCode: ['mc|mush'],
    MySQL: ['mysql'],
    Nix: ['nix'],
    NSIS: ['nsi|nsh'],
    ObjectiveC: ['m|mm'],
    OCaml: ['ml|mli'],
    Pascal: ['pas|p'],
    Perl: ['pl|pm'],
    pgSQL: ['pgsql'],
    PHP_Laravel_blade: ['blade.php'],
    PHP: ['php|phtml|shtml|php3|php4|php5|phps|phpt|aw|ctp|module'],
    Puppet: ['epp|pp'],
    Pig: ['pig'],
    Powershell: ['ps1'],
    Praat: ['praat|praatscript|psc|proc'],
    Prolog: ['plg|prolog'],
    Properties: ['properties'],
    Protobuf: ['proto'],
    Python: ['py'],
    R: ['r'],
    Razor: ['cshtml|asp'],
    RDoc: ['Rd'],
    Red: ['red|reds'],
    RHTML: ['Rhtml'],
    RST: ['rst'],
    Ruby: ['rb|ru|gemspec|rake|^Guardfile|^Rakefile|^Gemfile'],
    Rust: ['rs'],
    SASS: ['sass'],
    SCAD: ['scad'],
    Scala: ['scala'],
    Scheme: ['scm|sm|rkt|oak|scheme'],
    SCSS: ['scss'],
    SH: ['sh|bash|^.bashrc'],
    SJS: ['sjs'],
    Slim: ['slim|skim'],
    Smarty: ['smarty|tpl'],
    snippets: ['snippets'],
    Soy_Template: ['soy'],
    Space: ['space'],
    SQL: ['sql'],
    SQLServer: ['sqlserver'],
    Stylus: ['styl|stylus'],
    SVG: ['svg'],
    Swift: ['swift'],
    Tcl: ['tcl'],
    Terraform: ['tf', 'tfvars', 'terragrunt'],
    Tex: ['tex'],
    Text: ['txt'],
    Textile: ['textile'],
    Toml: ['toml'],
    TSX: ['tsx'],
    Twig: ['twig|swig'],
    Typescript: ['ts|typescript|str'],
    Vala: ['vala'],
    VBScript: ['vbs|vb'],
    Velocity: ['vm'],
    Verilog: ['v|vh|sv|svh'],
    VHDL: ['vhd|vhdl'],
    Wollok: ['wlk|wpgm|wtest'],
    XML: ['xml|rdf|rss|wsdl|xslt|atom|mathml|mml|xul|xbl|xaml'],
    XQuery: ['xq'],
    YAML: ['yaml|yml'],
    Django: ['html']
  }

  var nameOverrides = {
    ObjectiveC: 'Objective-C',
    CSharp: 'C#',
    golang: 'Go',
    C_Cpp: 'C and C++',
    Csound_Document: 'Csound Document',
    Csound_Orchestra: 'Csound',
    Csound_Score: 'Csound Score',
    coffee: 'CoffeeScript',
    HTML_Ruby: 'HTML (Ruby)',
    HTML_Elixir: 'HTML (Elixir)',
    FTL: 'FreeMarker',
    PHP_Laravel_blade: 'PHP (Blade Template)'
  }
  var modesByName = {}
  for (var name in supportedModes) {
    var data = supportedModes[name]
    var displayName = (nameOverrides[name] || name).replace(/_/g, ' ')
    var filename = name.toLowerCase()
    var mode = new Mode(filename, displayName, data[0])
    modesByName[filename] = mode
    modes.push(mode)
  }

  module.exports = {
    getModeForPath: getModeForPath,
    modes: modes,
    modesByName: modesByName
  }
})

define('ace/ext/themelist', ['require', 'exports', 'module', 'ace/lib/fixoldbrowsers'], function(require, exports, module) {
  'use strict'
  require('ace/lib/fixoldbrowsers')

  var themeData = [
    ['Chrome'],
    ['Clouds'],
    ['Crimson Editor'],
    ['Dawn'],
    ['Dreamweaver'],
    ['Eclipse'],
    ['GitHub'],
    ['IPlastic'],
    ['Solarized Light'],
    ['TextMate'],
    ['Tomorrow'],
    ['XCode'],
    ['Kuroir'],
    ['KatzenMilch'],
    ['SQL Server', 'sqlserver', 'light'],
    ['Ambiance', 'ambiance', 'dark'],
    ['Chaos', 'chaos', 'dark'],
    ['Clouds Midnight', 'clouds_midnight', 'dark'],
    ['Dracula', '', 'dark'],
    ['Cobalt', 'cobalt', 'dark'],
    ['Gruvbox', 'gruvbox', 'dark'],
    ['Green on Black', 'gob', 'dark'],
    ['idle Fingers', 'idle_fingers', 'dark'],
    ['krTheme', 'kr_theme', 'dark'],
    ['Merbivore', 'merbivore', 'dark'],
    ['Merbivore Soft', 'merbivore_soft', 'dark'],
    ['Mono Industrial', 'mono_industrial', 'dark'],
    ['Monokai', 'monokai', 'dark'],
    ['Pastel on dark', 'pastel_on_dark', 'dark'],
    ['Solarized Dark', 'solarized_dark', 'dark'],
    ['Terminal', 'terminal', 'dark'],
    ['Tomorrow Night', 'tomorrow_night', 'dark'],
    ['Tomorrow Night Blue', 'tomorrow_night_blue', 'dark'],
    ['Tomorrow Night Bright', 'tomorrow_night_bright', 'dark'],
    ['Tomorrow Night 80s', 'tomorrow_night_eighties', 'dark'],
    ['Twilight', 'twilight', 'dark'],
    ['Vibrant Ink', 'vibrant_ink', 'dark']
  ]

  exports.themesByName = {}
  exports.themes = themeData.map(function(data) {
    var name = data[1] || data[0].replace(/ /g, '_').toLowerCase()
    var theme = {
      caption: data[0],
      theme: 'ace/theme/' + name,
      isDark: data[2] == 'dark',
      name: name
    }
    exports.themesByName[name] = theme
    return theme
  })
})

define('ace/ext/options', ['require', 'exports', 'module', 'ace/ext/menu_tools/overlay_page', 'ace/lib/dom', 'ace/lib/oop', 'ace/lib/event_emitter', 'ace/ext/modelist', 'ace/ext/themelist'], function(require, exports, module) {
  'use strict'
  var overlayPage = require('./menu_tools/overlay_page').overlayPage

  var dom = require('../lib/dom')
  var oop = require('../lib/oop')
  var EventEmitter = require('../lib/event_emitter').EventEmitter
  var buildDom = dom.buildDom

  var modelist = require('./modelist')
  var themelist = require('./themelist')

  var themes = { Bright: [], Dark: [] }
  themelist.themes.forEach(function(x) {
    themes[x.isDark ? 'Dark' : 'Bright'].push({ caption: x.caption, value: x.theme })
  })

  var modes = modelist.modes.map(function(x) {
    return { caption: x.caption, value: x.mode }
  })

  var optionGroups = {
    Main: {
      Mode: {
        path: 'mode',
        type: 'select',
        items: modes
      },
      Theme: {
        path: 'theme',
        type: 'select',
        items: themes
      },
      'Keybinding': {
        type: 'buttonBar',
        path: 'keyboardHandler',
        items: [
          { caption: 'Ace', value: null },
          { caption: 'Vim', value: 'ace/keyboard/vim' },
          { caption: 'Emacs', value: 'ace/keyboard/emacs' }
        ]
      },
      'Font Size': {
        path: 'fontSize',
        type: 'number',
        defaultValue: 12,
        defaults: [
          { caption: '12px', value: 12 },
          { caption: '24px', value: 24 }
        ]
      },
      'Soft Wrap': {
        type: 'buttonBar',
        path: 'wrap',
        items: [
          { caption: 'Off', value: 'off' },
          { caption: 'View', value: 'free' },
          { caption: 'margin', value: 'printMargin' },
          { caption: '40', value: '40' }
        ]
      },
      'Cursor Style': {
        path: 'cursorStyle',
        items: [
          { caption: 'Ace', value: 'ace' },
          { caption: 'Slim', value: 'slim' },
          { caption: 'Smooth', value: 'smooth' },
          { caption: 'Smooth And Slim', value: 'smooth slim' },
          { caption: 'Wide', value: 'wide' }
        ]
      },
      'Folding': {
        path: 'foldStyle',
        items: [
          { caption: 'Manual', value: 'manual' },
          { caption: 'Mark begin', value: 'markbegin' },
          { caption: 'Mark begin and end', value: 'markbeginend' }
        ]
      },
      'Soft Tabs': [{
        path: 'useSoftTabs'
      }, {
        path: 'tabSize',
        type: 'number',
        values: [2, 3, 4, 8, 16]
      }],
      'Overscroll': {
        type: 'buttonBar',
        path: 'scrollPastEnd',
        items: [
          { caption: 'None', value: 0 },
          { caption: 'Half', value: 0.5 },
          { caption: 'Full', value: 1 }
        ]
      }
    },
    More: {
      'Atomic soft tabs': {
        path: 'navigateWithinSoftTabs'
      },
      'Enable Behaviours': {
        path: 'behavioursEnabled'
      },
      'Full Line Selection': {
        type: 'checkbox',
        values: 'text|line',
        path: 'selectionStyle'
      },
      'Highlight Active Line': {
        path: 'highlightActiveLine'
      },
      'Show Invisibles': {
        path: 'showInvisibles'
      },
      'Show Indent Guides': {
        path: 'displayIndentGuides'
      },
      'Persistent Scrollbar': [{
        path: 'hScrollBarAlwaysVisible'
      }, {
        path: 'vScrollBarAlwaysVisible'
      }],
      'Animate scrolling': {
        path: 'animatedScroll'
      },
      'Show Gutter': {
        path: 'showGutter'
      },
      'Show Line Numbers': {
        path: 'showLineNumbers'
      },
      'Relative Line Numbers': {
        path: 'relativeLineNumbers'
      },
      'Fixed Gutter Width': {
        path: 'fixedWidthGutter'
      },
      'Show Print Margin': [{
        path: 'showPrintMargin'
      }, {
        type: 'number',
        path: 'printMarginColumn'
      }],
      'Indented Soft Wrap': {
        path: 'indentedSoftWrap'
      },
      'Highlight selected word': {
        path: 'highlightSelectedWord'
      },
      'Fade Fold Widgets': {
        path: 'fadeFoldWidgets'
      },
      'Use textarea for IME': {
        path: 'useTextareaForIME'
      },
      'Merge Undo Deltas': {
        path: 'mergeUndoDeltas',
        items: [
          { caption: 'Always', value: 'always' },
          { caption: 'Never', value: 'false' },
          { caption: 'Timed', value: 'true' }
        ]
      },
      'Elastic Tabstops': {
        path: 'useElasticTabstops'
      },
      'Incremental Search': {
        path: 'useIncrementalSearch'
      },
      'Read-only': {
        path: 'readOnly'
      },
      'Copy without selection': {
        path: 'copyWithEmptySelection'
      },
      'Live Autocompletion': {
        path: 'enableLiveAutocompletion'
      }
    }
  }

  var OptionPanel = function(editor, element) {
    this.editor = editor
    this.container = element || document.createElement('div')
    this.groups = []
    this.options = {}
  };

  (function() {
    oop.implement(this, EventEmitter)

    this.add = function(config) {
      if (config.Main) { oop.mixin(optionGroups.Main, config.Main) }
      if (config.More) { oop.mixin(optionGroups.More, config.More) }
    }

    this.render = function() {
      this.container.innerHTML = ''
      buildDom(['table', { id: 'controls' },
        this.renderOptionGroup(optionGroups.Main),
        ['tr', null, ['td', { colspan: 2 },
          ['table', { id: 'more-controls' },
            this.renderOptionGroup(optionGroups.More)
          ]
        ]]
      ], this.container)
    }

    this.renderOptionGroup = function(group) {
      return Object.keys(group).map(function(key, i) {
        var item = group[key]
        if (!item.position) { item.position = i / 10000 }
        if (!item.label) { item.label = key }
        return item
      }).sort(function(a, b) {
        return a.position - b.position
      }).map(function(item) {
        return this.renderOption(item.label, item)
      }, this)
    }

    this.renderOptionControl = function(key, option) {
      var self = this
      if (Array.isArray(option)) {
        return option.map(function(x) {
          return self.renderOptionControl(key, x)
        })
      }
      var control

      var value = self.getOption(option)

      if (option.values && option.type != 'checkbox') {
        if (typeof option.values === 'string') { option.values = option.values.split('|') }
        option.items = option.values.map(function(v) {
          return { value: v, name: v }
        })
      }

      if (option.type == 'buttonBar') {
        control = ['div', option.items.map(function(item) {
          return ['button', {
            value: item.value,
            ace_selected_button: value == item.value,
            onclick: function() {
              self.setOption(option, item.value)
              var nodes = this.parentNode.querySelectorAll('[ace_selected_button]')
              for (var i = 0; i < nodes.length; i++) {
                nodes[i].removeAttribute('ace_selected_button')
              }
              this.setAttribute('ace_selected_button', true)
            }
          }, item.desc || item.caption || item.name]
        })]
      } else if (option.type == 'number') {
        control = ['input', { type: 'number', value: value || option.defaultValue, style: 'width:3em', oninput: function() {
          self.setOption(option, parseInt(this.value))
        } }]
        if (option.defaults) {
          control = [control, option.defaults.map(function(item) {
            return ['button', { onclick: function() {
              var input = this.parentNode.firstChild
              input.value = item.value
              input.oninput()
            } }, item.caption]
          })]
        }
      } else if (option.items) {
        var buildItems = function(items) {
          return items.map(function(item) {
            return ['option', { value: item.value || item.name }, item.desc || item.caption || item.name]
          })
        }

        var items = Array.isArray(option.items)
          ? buildItems(option.items)
          : Object.keys(option.items).map(function(key) {
            return ['optgroup', { 'label': key }, buildItems(option.items[key])]
          })
        control = ['select', { id: key, value: value, onchange: function() {
          self.setOption(option, this.value)
        } }, items]
      } else {
        if (typeof option.values === 'string') { option.values = option.values.split('|') }
        if (option.values) value = value == option.values[1]
        control = ['input', { type: 'checkbox', id: key, checked: value || null, onchange: function() {
          var value = this.checked
          if (option.values) value = option.values[value ? 1 : 0]
          self.setOption(option, value)
        } }]
        if (option.type == 'checkedNumber') {
          control = [control, []]
        }
      }
      return control
    }

    this.renderOption = function(key, option) {
      if (option.path && !option.onchange && !this.editor.$options[option.path]) { return }
      this.options[option.path] = option
      var safeKey = '-' + option.path
      var control = this.renderOptionControl(safeKey, option)
      return ['tr', { class: 'ace_optionsMenuEntry' }, ['td',
        ['label', { for: safeKey }, key]
      ], ['td', control]]
    }

    this.setOption = function(option, value) {
      if (typeof option === 'string') { option = this.options[option] }
      if (value == 'false') value = false
      if (value == 'true') value = true
      if (value == 'null') value = null
      if (value == 'undefined') value = undefined
      if (typeof value === 'string' && parseFloat(value).toString() == value) { value = parseFloat(value) }
      if (option.onchange) { option.onchange(value) } else if (option.path) { this.editor.setOption(option.path, value) }
      this._signal('setOption', { name: option.path, value: value })
    }

    this.getOption = function(option) {
      if (option.getValue) { return option.getValue() }
      return this.editor.getOption(option.path)
    }
  }).call(OptionPanel.prototype)

  exports.OptionPanel = OptionPanel
});
(function() {
  window.require(['ace/ext/options'], function(m) {
    if (typeof module === 'object' && typeof exports === 'object' && module) {
      module.exports = m
    }
  })
})()
